﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//int main()
//{
//    int arr[] = { 1,2,3,4,5 };
//    short* p = (short*)arr;
//    int i = 0;
//    for (i = 0; i < 4; i++)
//    {
//        *(p + i) = 0;
//    }
//
//    for (i = 0; i < 5; i++)
//    {
//        printf("%d ", arr[i]);
//    }
//    return 0;
//}




//void test()
//{
//	int n = 10;
//	int m = 30;
//	int* p = &n;
//	*p = 20;
//	p = &m;
//}
//void test1()
//{
//	int n = 10;
//	int m = 200;
//	const int* p = &n;
//	//*p=200;不能这么写
//	p = &m;
//	printf("%d", *p);
//	//const在*的左边，限制的是*p，不能通过指针变量p修改p指向空间的内容，但是p是不受限制的
//}
//void test2()
//{
//	int n = 10;
//	int m = 300;
//	int* const p = &n;
//	*p = 100;
//	//p = &m;
//	printf("%p", p);
//	//const放在*的右边，修饰的指针变量本身，保证了指针变量的内容不能修改，但指针指向的内容可以修改
//}
//test3()
//{
//	int n = 10;
//	int m = 20;
//	int const* const p = &n;
//	//*p=300;
//	//p=&m;
//}
//int main()
//{
//	test();
//	test1();
//	test2();
//	test3();
//	return 0;
//}



//#include<stdio.h>
//#include<string.h>
//int main() {
//    char str[10001] = { 0 };
//    while (gets(str)) { 
//        int len = strlen(str);
//        for (int i = len - 1; i >= 0; i--)
//        {
//            printf("%c", str[i]);
//        }
//    }
//}



//int main()
//{
//	int arr[10] = {0};
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int j = 0;
//	for (j = 0; j < 10; j++)
//	{
//		printf("%d", arr[j]);
//	}
//	return 0;
//}


//实现一个函数，可以左旋字符串中的k个字符。
//例如：
//ABCD左旋一个字符得到BCDA
//
//ABCD左旋两个字符得到CDAB
//#include<string.h>
//int main()
//{
//	char arr[10] = { 0 };
//	int k = 0;
//	int i = 0;
//	scanf("%d", &k);
//	while (gets(arr))
//	{
//		int len = strlen(arr);
//		for (i = k; i < len; i++)
//		{
//			printf("%c", arr[i]);
//		}
//		for (i = 0; i < k;i++)
//		{
//			printf("%c", arr[i]);
//
//		}
//	}
//
//	return 0;
//}



//模拟实现库函数strlen
//int my_strlen(char * arr)
//{
//	int i = 0;
//	while (*arr)
//	{
//		arr++;
//		i++;
//	}
//	return i;
//}
//int main()
//{
//	char arr[] = "abcd";
//	int i = 0;
//	int len = my_strlen(arr);
//	printf("%d", len);
//	return 0;
//}

//#include <stdio.h>
//void Swap1(int x, int y)
//{
//	int z = 0;
//	z = x;
//	x = y;
//	y = z;
//}
//
////void Swap2(int*pa, int*pb)
////{
////	int z = 0;
////	z = *pa;  //z = a;
////	*pa = *pb;//a = b
////	*pb = z;  //b = z
////}
//
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	//交换a和b的值
//
//	printf("交换前：a=%d b=%d\n", a, b);
//	Swap1(a, b);//传值调用
//	//Swap2(&a, &b);//传址调用
//
//	printf("交换后：a=%d b=%d\n", a, b);
//	
//	return 0;
//}


//int main()
//{
//	int* p;
//	*p = 20;
//	printf("%d",*p);
//	return 0;
//}



//int* test()
//{
//	int a = 10;
//	//...
//	return &a;
//}
//int main()
//{
//	int*p = test();
//
//	//printf("hehe\n");//为什么这里加了一句代码，*p的值就变了
//
//	printf("%d\n", *p);
//
//	return 0;
//}


//int main()
//{
//	int n = 0x11223344;
//	char* pi =(char*) & n;
//	*pi = 0;
//	printf("%d", *pi);
//	return 0;
//}




//int main()
//{
//	int n = 10;
//	char* pc = (char*)&n;
//	int* pi = &n;
//
//	printf("%p\n", &n);
//	printf("%p\n", pc);
//	printf("%p\n", pc+1);
//	printf("%p\n", pi);
//	printf("%p\n", pi+1);
//
//	return 0;
//}



//void Print(int* arr, int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", *(arr+i));//arr[i] == *(arr+i)
//	}
//}



//void Print(int arr[])
//{
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		printf("%d ", arr[i]);//arr[i] == *(arr+i)
//	}
//}



//void test(int* arr)
//{
//	int sz = sizeof(arr);
//	printf("%d\n", sz);//?
//}
//int main()
//{
//	
//	int arr[12] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//
//	test(arr);//这里的数组名就是数组首元素的地址
//	//Print(arr, sz);//降级
//	printf("%d", sz);
//	return 0;
//}



//冒泡排序
//void bubble_sort(int* arr, int sz)
//{
//	int i = 0;//行
//	for (i = 0; i < sz - 1; i++)//sz-1只需要9趟例如9 8 7 6 5 4 3 2 1最后的0就不需要排序
//	{
//		int j = 0;//列
//		for (j = 0; j < sz - i - 1; j++)//sz-1-i，为什么sz要减1，是因为下面j+1，如果不减1，栈溢出
//		{
//
//			if ((*(arr + j)) > (*(arr + j + 1)))
//			{
//				int t = *(arr + j + 1);
//				*(arr + j + 1) = *(arr + j);
//				*(arr + j) = t;
//			}
//		}
//	}
//}
//int main()
//{
//	int arr[10] = { 0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//	for (i=0; i < sz; i++)
//	{
//		scanf("%d", arr + i);
//	}
//	printf("\n");
//	bubble_sort(arr, sz);
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}



//二级指针
//int main()
//{
//	int a = 10;
//	int* p = &a;//取出a的地址
//	//p是指针变量，是一级指针
//	int * * pp = &p;//pp是二级指针
//
//	return 0;
//}



//写一个函数打印arr数组的内容，不使用数组下标，使用指针。
//
//arr是一个整形一维数组。
//void Print(int* arr,int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", *(arr + i));
//	}
//}
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	Print(arr , sz);
//	return 0;
//}




//调整数组使奇数全部都位于偶数前面。
//题目：
//
//输入一个整数数组，实现一个函数，
//
//来调整该数组中数字的顺序使得数组中所有的奇数位于数组的前半部分，
//
//所有偶数位于数组的后半部分。
//
//void order(int* arr,int*arr1, int sz)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < 10; i++)
//	{
//		if (*(arr+i) % 2 == 0)
//		{
//			*(arr1+sz-1) = *(arr+i);
//			sz--;
//		}
//		else
//		{
//			*(arr1+j) = *(arr+i);
//			j++;
//		}
//	}
//}
//int main()
//{
//	int i = 0;
//	int arr[10] = { 2,4,6,8,10,1,3,5,7,9 };
//	int arr1[10] = { 0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	order(arr,arr1, sz);
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr1[i]);
//	}
//	return 0;
//}


/*
思路：
1. 给定两个下标left和right，left放在数组的起始位置，right放在数组中最后一个元素的位置
2. 循环进行一下操作
 a. 如果left和right表示的区间[left, right]有效，进行b，否则结束循环
 b. left从前往后找，找到一个偶数后停止
 c. right从后往前找，找到一个奇数后停止
 d. 如果left和right都找到了对应的数据，则交换，继续a，
*/
//void swap_arr(int arr[], int sz)
//{
//	int left = 0;
//	int right = sz - 1;
//	int tmp = 0;
//
//
//	while (left < right)
//	{
//		// 从前往后，找到一个偶数，找到后停止
//		while ((left < right) && (arr[left] % 2 == 1))
//		{
//			left++;
//		}
//
//		// 从后往前找，找一个奇数，找到后停止
//		while ((left < right) && (arr[right] % 2 == 0))
//		{
//			right--;
//		}
//
//		// 如果偶数和奇数都找到，交换这两个数据的位置
//		// 然后继续找，直到两个指针相遇
//		if (left < right)
//		{
//			tmp = arr[left];
//			arr[left] = arr[right];
//			arr[right] = tmp;
//		}
//	}
//}
//int main()
//{
//	int i = 0;
//	int arr[10] = { 2,4,6,8,10,1,3,5,7,9 };
//	//int arr1[10] = { 0 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	swap_arr(arr, sz);
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}



//int main()
//{
//	int arr1[] = { 1,2,3,4,5 };
//	int arr2[] = { 2,3,4,5,6 };
//	int arr3[] = { 3,4,5,6,7 };
//
//	int* arr[3] = {arr1, arr2, arr3};//整型指针数组
//
//	int i = 0;
//
//	for (i = 0; i < 3; i++)
//	{
//		int j = 0;
//		for (j = 0; j < 5; j++)
//		{
//			printf("%d ", arr[i][j]);
//		}
//		printf("\n");
//	}
//
//	return 0;
//}



//在屏幕上打印杨辉三角。
//1
//
//1 1
//
//1 2 1
//
//1 3 3 1
//
//int main()
//{
//	int i = 0;//行
//	scanf("%d", &i);
//	int j = 0;
//	int k = 0;
//	for (j = 1; j <= i; j++)
//	{
//		int z = i;
//		while (j < z)
//		{
//			printf(" ");
//			z--;
//		}
//		for (k = 0; k < j; k++)
//		{
//			printf("1 ");
//		}
//		printf("\n");
//	}
//	return 0;
//}
    /**
   * *
  * * *
 * * * **/
//#include <stdio.h>
//
//int main() {
//    int i = 0; // 行
//    scanf("%d", &i);
//    int j = 0;
//    int k = 0;
//
//    for (j = 0; j < i; j++) 
//    {
//        int spaces = i - j - 1;  // 计算每行前面的空格数
//        for (k = 0; k < spaces; k++)
//        {
//            printf(" ");  // 输出空格
//        }
//        int num = 1;
//        for (k = 0; k <= j; k++) 
//        {
//            printf("%-2d ", num);  // 输出数字并留有空间
//            num = num * (j - k) / (k + 1);  // 计算下一个数字
//        }
//        printf("\n");
//    }
//    return 0;
//}


//日本某地发生了一件谋杀案，警察通过排查确定杀人凶手必为4个嫌疑犯的一个。
//以下为4个嫌疑犯的供词:
//
//A说：不是我。
//
//B说：是C。
//
//C说：是D。
//
//D说：C在胡说
//
//已知3个人说了真话，1个人说的是假话。
//现在请根据这些信息，写一个程序来确定到底谁是凶手。
//int main()
//{
//
//	
//		char killer;
//		for (killer = 'A'; killer <= 'D'; killer++)//巧妙地利用ASCII 从A-D进行循环和比较
//		{
//			//下面分别对应每个人都供词  不是A 是C     是D    不是D
//			if (((killer != 'A') + (killer == 'C') + (killer == 'D') + (killer != 'D')) == 3)  //这里等于3表示 有三个人说了真话
//			{
//				printf("%c是凶手\n", killer);
//				break;
//			}
//		}
//		
//    return 0;
//}




//有一个数字矩阵，矩阵的每行从左到右是递增的，矩阵从上到下是递增的，请编写程序在这样的矩阵中查找某个数字是否存在。
//要求：时间复杂度小于O(N);
//int main()
//{
//    int i = 0;
//    int arr[2][3] = { {1,2,3},{4,5,6} };
//    int Find = 0;
//    scanf("%d", &Find);
//    for (i = 0; i < 2; i++)
//    {
//        if (arr[i][3] < Find)
//        {
//            if()
//        }
//    }
//    return 0;
//}
//写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字符串。
//例如：给定s1 = AABCD和s2 = BCDAA，返回1
//给定s1 = abcd和s2 = ACBD，返回0.
//AABCD左旋一个字符得到ABCDA
//AABCD左旋两个字符得到BCDAA
//AABCD右旋一个字符得到DAABC
//int Back(char* arr, int sz)
//{
//    int i = 0;
//    int string = 0;
//    for (i = 0; i < sz; i++)
//    {
//        scanf("%c", &arr[i]);
//        
//    }
//    for (i = 0; i < sz; i++)
//    {
//        if (arr[i] <= 'Z' && arr[i] >= 'A')
//        {
//            return 1;
//        }
//    }
//    return 0;
//}
//void Spin(char* arr, int sz)
//{
//    int i = 0;
//    int left=0;
//    int right = 0;
//    int chose = 0;
//    printf("1=left 2=right\n");
//    scanf("%d", &chose);
//    switch(chose)
//    {
//    case 1:
//        printf("旋转几个数字\n");
//        scanf("%d", &left);
//        for (i = sz-left-1; i<sz; i++)
//        {
//            printf("%c", arr[i]);
//        }
//        for (i = 0; i < left; i++)
//        {
//            printf("%c", arr[i]);
//        }
//        break;
//    case 2:
//        printf("旋转几个数字\n");
//        scanf("%d", &right);
//        for (i = sz - right; i < sz; i++)
//        {
//            printf("%c", arr[i]);
//        }
//        for (i = 0; i < sz - right; i++)
//        {
//            printf("%c", arr[i]);
//        }
//        break;
//    }
//}
//int main()
//{
//    char arr[5] = {0};
//    int sz=sizeof(arr) / sizeof(arr[0]);
//    int result = Back(arr, sz);
//    printf("%d\n", result);
//    Spin(arr, sz);
//    return 0;
//}


//void menu()
//{
//	printf("******************************\n");
//	printf("****  1. add     2. sub   ****\n");
//	printf("****  3. mul     4. div   ****\n");
//	printf("****  0. exit             ****\n");
//	printf("******************************\n");
//}
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int Sub(int x, int y)
//{
//	return x - y;
//}
//
//int Mul(int x, int y)
//{
//	return x * y;
//}
//
//int Div(int x, int y)
//{
//	return x / y;
//}
//
//
//int main()
//{
//	int input = 0;
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	int(*p[5])(int, int) = {0,Add,Sub,Mul,Div};//p先和[]结合说明p是数组*说明是指针数组而函数指针变量是int(*)()
//	do
//	{
//		menu();
//		scanf("%d", &input);
//		if (input >= 1 && input <= 4)
//		{
//			printf("输入两个数:");
//			scanf("%d %d", &x, &y);
//			ret = (*p[input])(x, y);//---------(*p[input])(x,y)-------*解引用p[input]
//			printf("%d\n",ret);
//		}
//		else if (input == 0)
//		{
//			printf("退出");
//		}
//		else
//		{
//			printf("输入有误");
//		}
//	} while (input);
//	
//	return 0;
//}

//void menu()
//{
//	printf("******************************\n");
//	printf("****  1. add     2. sub   ****\n");
//	printf("****  3. mul     4. div   ****\n");
//	printf("****  0. exit             ****\n");
//	printf("******************************\n");
//}
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int Sub(int x, int y)
//{
//	return x - y;
//}
//
//int Mul(int x, int y)
//{
//	return x * y;
//}
//
//int Div(int x, int y)
//{
//	return x / y;
//}
//void calc(int (*pf)(int,int))
//{
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	printf("请输入两个操作数:");
//	scanf("%d %d", &x, &y);
//	ret = pf(x, y);
//	printf("%d\n", ret);
//}
//int main()
//{
//	int input = 0;
//	
//	do
//	{
//		menu();
//		printf("请选择:");
//		scanf("%d", &input);
//		switch (input)
//		{
//		case 1:
//			calc(Add);//完成计算	
//			break;
//		case 2:
//			calc(Sub);
//			break;
//		case 3:
//			calc(Mul);
//			break;
//		case 4:
//			calc(Div);
//			break;
//		case 0:
//			printf("退出计算器\n");
//			break;
//		default:
//			printf("选择错误，重新选择\n");
//			break;
//		}
//	} while (input);
//
//	return 0;
//}



//int main()
//{
//    int a[5] = { 1,2,3,4,5 };
//    int* ptr = &a + 1;
//    printf("%d    %d", *(a + 1), *(ptr - 1));
//    return 0;
//}



//KiKi想获得某年某月有多少天，请帮他编程实现。输入年份和月份，计算这一年这个月有多少天。
//输入描述：
//多组输入，一行有两个整数，分别表示年份和月份，用空格分隔。
//输出描述：
//针对每组输入，输出为一行，一个整数，表示这一年这个月有多少天。

//void judgment(int year, int month)
//{
//    if (year % 4 == 0 &&year % 100 != 0 ||year%400==0)
//    {
//        if (month <= 12)
//        {
//            
//            if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
//            {
//                printf("31\n");
//            }
//            else if (month == 2)
//            {
//                printf("29\n");
//            }
//            else
//            {
//                printf("30\n");
//
//            }
//        }
//       
//    }
//    else
//    {
//        if (month <= 12)
//        {
//
//            if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
//            {
//                printf("31\n");
//            }
//            else if (month == 2)
//            {
//                printf("28\n");
//            }
//            else
//            {
//                printf("30\n");
//
//            }
//        }
//    }
//}
//int main()
//{
//    int year = 0, month = 0, day = 0;
//    while (scanf("%d %d", &year, &month) != EOF)
//    {
//        judgment(year, month);
//
//   }
//    return 0;
//}


//#include <stdio.h>
//int main()
//{
//    int y = 0;
//    int m = 0;
//    int days[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
//    while (scanf("%d%d", &y, &m) != EOF)
//    {
//        int day = days[m - 1];
//        if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
//        {
//            if (m == 2)
//                day += 1;
//        }
//        printf("%d\n", day);
//    }
//    return 0;
//}




//一个数组中只有两个数字是出现一次，其他所有数字都出现了两次。
//
//编写一个函数找出这两个只出现一次的数字。
//
//
//
//例如：
//
//有数组的元素是：1，2，3，4，5，1，2，3，4，6
//
//只有5和6只出现1次，要找出5和6.
//void Find_dog(int* arr,int len)
//{
//    int i = 0;
//    for (i = 0; i < len; i++)
//    {
//        int j = 0;
//        int tmp = 0;
//        for (j = 0; j < len; j++)
//        {
//            if (*(arr + i) == *(arr + j))
//            {
//                tmp++;
//            }
//        }
//        if (tmp == 1)
//        {
//            printf("find dog %d\n", *(arr + i));
//        }
//    }
//}
//int main()
//{
//    int arr[] = { 1,2,3,4,5,1,2,3,4,6 };
//    int len = sizeof(arr) / sizeof(arr[0]);
//    Find_dog(arr,len);
//    return 0;
//}

//void findTwoNum(int arr[], int n, int* pnum1, int* pnum2)
//{
//    int i=0;
//    int sum = 0;
//    ​
//        for (i = 0; i < 9; i++)
//        {
//            sum ^= arr[i];
//        } //先找到两个数互相异或的结果
//    ​
//        int pos;
//    for (i = 0; i < 32; i++)
//    {
//        if (sum & 1 << i)
//        {
//            pos = i;
//            break;
//        }
//    } //再找到有分歧的一位。在这一位上，两个数一定是一个1一个0
//    ​
//        * pnum1 = *pnum2 = 0;
//    for (i = 0; i < 10; i++)
//    {
//        if (arr[i] & 1 << pos)
//        {
//            *pnum1 ^= arr[i]; //这一位是1的，放在数1里
//        }
//        else
//        {
//            *pnum2 ^= arr[i]; //这一位是0的，放在数2里
//        }
//    }
//}

//void qsort(void* base, size_t num, size_t size,
//    int (*compar)(const void*, const void*));
//练习使用库函数，qsort排序各种类型的数据
//int int_cmp(const void* p1, const void* p2)
//{
//    return (*(int*)p1 - *(int*)p2);
//}
//int main()
//{
//    int arr[] = { 1,3,5,7,9,2,4,6,8,0 };
//    int i = 0;
//    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
//    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//    {
//        printf("%d ", arr[i]);
//    }
//    return 0;
//}


//int my_strcmp(const char* s1, const char* s2)
//{
//    while (*s1 == *s2)
//    {
//        if (*s1 == '\0')
//            return 0;
//        s1++;
//        s2++;
//    }
//    return *s1 - *s2;
//}
//int main()
//{
//    int ret = my_strcmp("abc", "abc");
//    if (ret > 0)
//        printf("大于");
//    else if (ret == 0)
//        printf("==");
//    else
//        printf("<");
//    return 0;
//}

//int main()
//{
//    while ('\0' == '\0')
//    {
//        printf("1");
//    }
//    return 0;
//}





//void qsort(void* base, size_t num, size_t size,
//    int (*compar)(const void*, const void*));
// 模拟使用
//void cmp(const void*p1,const void*p2)
//{
//    return (*(int*)p1) - (*(int*)p2);
//}
//int main()
//{
//    int arr[] = { 1,2,3,4,5,9,8,7,6 };
//    int i = 0;
//    qsort(arr, sizeof(arr) / sizeof(arr[0]),sizeof(int),cmp);
//    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//    {
//        printf("%d ", arr[i]);
//    }
//    return 0;
//}
//struct Stu
//{
//    char name[20];
//    int age;
//};
//
////年龄
//int cmp(const void* p1, const void* p2)
//{
//    return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
//}
//void test()
//{
//    struct  Stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",15} };
//    int sz = sizeof(s) / sizeof(s[0]);
//    qsort(s, sz, sizeof(s[0]), cmp);
//    for (int i = 0; i < sz; i++)
//    {
//        printf("Name: %s, Age: %d\n", s[i].name, s[i].age);
//    }
//   
//}
//int main()
//{
//    test();
//    return 0;
//}



//struct Stu
//{
//    char name[20];
//    int age;
//};
//
////姓名
//int cmp(const void* p1, const void* p2)
//{
//    return strcmp(((struct Stu*)p1)->name - ((struct Stu*)p2)->name);
//}
//void test()
//{
//    struct  Stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",15} };
//    int sz = sizeof(s) / sizeof(s[0]);
//    qsort(s, sz, sizeof(s[0]), cmp);
//}
//int main()
//{
//    test();
//    return 0;
//}



//void qsort(void* base, size_t num, size_t size,
//    int (*compar)(const void*, const void*));

//模仿qsort的功能实现一个通用的冒泡排序
//int dizhi(const void* p1, const void* p2)
//{
//    return (*(int*)p1 - *(int*)p2);
//}
//
//void swap(void* p1, void* p2, int size)
//{
//    int i = 0;
//    for (i = 0; i < size; i++)
//    {
//        char tmp = *((char*)p1 + i);
//        *((char*)p1 + i) = *((char*)p2 + i);
//        *((char*)p2 + i) = tmp;
//    }
//}
//
//void bubble(void* arr, int sz, int size, int(*dizhi)(void*, void*))
//{
//    int i = 0;
//    int j = 0;
//    for (i = 0; i < sz - 1; i++)
//    {
//        for (j = 0; j < sz - 1 - i; j++)
//        {
//            if (dizhi((char*)arr + j * size, (char*)arr + (j + 1) * size) > 0)
//            {
//                swap((char*)arr + j * size, (char*)arr + (j + 1) * size, size);
//            }
//        }
//    }
//}
//
//int main()
//{
//    int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    bubble(arr, sz, sizeof(arr[0]), dizhi);
//
//    // Print sorted array
//    for (int i = 0; i < sz; i++) {
//        printf("%d ", arr[i]);
//    }
//
//    return 0;
//}



//void qsort(void* base, size_t num, size_t size,
//    int (*compar)(const void*, const void*));
//int cmp(const void* p1, const void* p2)
//{
//    return ((*(int*)p1) - (*(int*)p2));
//}
//void swap(void* p1, void* p2, int size)
//{
//    int i = 0;
//        for (i = 0; i < size; i++)
//        {
//            char tmp = *((char*)p1 + i);
//            *((char*)p1 + i) = *((char*)p2 + i);
//            *((char*)p2 + i) = tmp;
//        }
//    
//}
//void bubble(void* base, int num, int size, int (*cmp)(const void*, const void*))
//{
//    int i = 0;
//    int j = 0;
//    for (i = 0; i < num - 1; i++)
//    {
//        for (j = 0; j < num - 1 - i; j++)
//        {
//            if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
//            {
//                swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
//            }
//        }
//    }
//}
//int main()
//{
//    int arr[] = { 2,3,1,5,6,8,9,7 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    bubble(arr, sz, sizeof(arr[0]), cmp);//cmp--回调函数就是一个参数，将这个函数作为参数传到另一个函数里面，当那个函数执行完之后，再执行传进去的这个函数
//    for (int i = 0; i < sz; i++) {
//                printf("%d ", arr[i]);
//            }
//    return 0;
//}




//void test(int(*p)[2], int a, int b)
//{
//    int i = 0;
//    int j = 0;
//    for (i = 0; i < a; i++)
//    {
//        for (j = 0; j < b; j++)
//        {
//            printf("%d", *(*(p + i) + j));
//        }
//        printf("\n");
//    }
//}
//int main()
//{
//    int arr[2][2] = { {1,2},{3,4} };
//    test(arr, 2, 2);
//
//    return 0;
//}
